.TH std::is_const 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::is_const \- std::is_const

.SH Synopsis
   Defined in header <type_traits>
   template< class T >              \fI(since C++11)\fP
   struct is_const;

   std::is_const is a UnaryTypeTrait.

   If T is a const-qualified type (that is, const, or const volatile), provides the
   member constant value equal to true. For any other type, value is false.

   If the program adds specializations for std::is_const or std::is_const_v, the
   behavior is undefined.

.SH Template parameters

   T - a type to check

   Helper variable template

   template< class T >                                     \fI(since C++17)\fP
   inline constexpr bool is_const_v = is_const<T>::value;



Inherited from std::integral_constant

.SH Member constants

   value    true if T is a const-qualified type, false otherwise
   \fB[static]\fP \fI(public static member constant)\fP

.SH Member functions

   operator bool converts the object to bool, returns value
                 \fI(public member function)\fP
   operator()    returns value
   \fI(C++14)\fP       \fI(public member function)\fP

.SH Member types

   Type       Definition
   value_type bool
   type       std::integral_constant<bool, value>

.SH Notes

   If T is a reference type then is_const<T>::value is always false. The proper way to
   check a potentially-reference type for const-ness is to remove the reference:
   is_const<typename remove_reference<T>::type>.

.SH Possible implementation

   template<class T> struct is_const          : std::false_type {};
   template<class T> struct is_const<const T> : std::true_type {};

.SH Example


// Run this code

 #include <type_traits>

 static_assert(std::is_same_v<const int*, int const*>,
     "Remember, const-ness binds tightly inside pointers.");
 static_assert(!std::is_const_v<int>);
 static_assert(std::is_const_v<const int>);
 static_assert(!std::is_const_v<int*>);
 static_assert(std::is_const_v<int* const>,
     "Because the pointer itself can't be changed but the int pointed at can.");
 static_assert(!std::is_const_v<const int*>,
     "Because the pointer itself can be changed but not the int pointed at.");
 static_assert(!std::is_const_v<const int&>);
 static_assert(std::is_const_v<std::remove_reference_t<const int&>>);

 struct S
 {
     void foo() const {}
     void bar() const {}
 };

 int main()
 {
     // A const member function is const in a different way:

     static_assert(!std::is_const_v<decltype(&S::foo)>,
         "Because &S::foo is a pointer.");

     using S_mem_fun_ptr = void(S::*)() const;

     S_mem_fun_ptr sfp = &S::foo;
     sfp = &S::bar; // OK, can be re-pointed
     static_assert(!std::is_const_v<decltype(sfp)>,
         "Because sfp is the same pointer type and thus can be re-pointed.");

     const S_mem_fun_ptr csfp = &S::foo;
     // csfp = &S::bar; // Error
     static_assert(std::is_const_v<decltype(csfp)>,
         "Because csfp cannot be re-pointed.");
 }

.SH See also

   is_volatile checks if a type is volatile-qualified
   \fI(C++11)\fP     \fI(class template)\fP
   as_const    obtains a reference to const to its argument
   \fI(C++17)\fP     \fI(function template)\fP
